@ocap/tx-protocols 1.28.8 → 1.29.0

package/tools/fixtures.ts

@@ -0,0 +1,564 @@
+import { spyOn } from 'bun:test';
+import GraphQLClient from '@ocap/client';
+import MemoryStateDB from '@ocap/statedb-memory';
+import crypto from 'node:crypto';
+import cloneDeep from 'lodash/cloneDeep';
+import { types, getRandomBytes, toTxHash } from '@ocap/mcrypto';
+import { fromRandom } from '@ocap/wallet';
+import { createMessage, fromTypeUrl } from '@ocap/message';
+import { toBase64, toBN, fromUnitToToken, fromTokenToUnit, toBase58 } from '@ocap/util';
+import * as states from '@ocap/state';
+import * as JWT from '@arcblock/jwt';
+import { toStakeAddress, toTokenAddress, toTokenFactoryAddress } from '@arcblock/did-util';
+import { create as createVC } from '@arcblock/vc';
+import { getTestChain, closeTestChain } from '@ocap/e2e-test/fixture';
+import defaultConfigModule from '@ocap/e2e-test/config';
+
+// @ts-ignore - compiled output
+import { execute, createExecutor } from '../lib';
+
+const defaultConfig = cloneDeep(defaultConfigModule);
+
+const lambdaExecutor = createExecutor({
+  filter: new (states as any).Blacklist(),
+  runAsLambda: (cb: () => void) => cb(),
+});
+
+export const statedb = new MemoryStateDB();
+
+// Client will be initialized in setup()
+let _client: any = null;
+
+// Setup function - call this in beforeAll()
+export const setup = async () => {
+  const chain = await getTestChain();
+  _client = new GraphQLClient(chain.endpoint);
+  // Update chainId in both defaultConfig and config
+  (defaultConfig as any).chainId = chain.config.chainId;
+  config.chainId = chain.config.chainId;
+  console.log(`Test chain ready at ${chain.endpoint}`);
+  return chain;
+};
+
+// Teardown function - call this in afterAll()
+export const teardown = () => {
+  closeTestChain();
+};
+
+// Getter for client (ensures setup was called)
+const getClient = () => {
+  if (!_client) {
+    throw new Error('Client not initialized. Call setup() in beforeAll() first.');
+  }
+  return _client;
+};
+
+// Export client as a Proxy that delegates all method calls to the initialized client
+// This allows test files to use client.someMethod() directly while the actual client
+// is lazily initialized in setup()
+export const client: any = new Proxy({}, {
+  get(_target, prop) {
+    return getClient()[prop];
+  },
+});
+
+export const getTxHash = () => getRandomBytes(32);
+
+export const getTxBase64 = (tx: any) => {
+  const txObj = createMessage('Transaction', tx);
+  if (!txObj) {
+    throw new Error('Failed to create Transaction message');
+  }
+  const txBytes = txObj.serializeBinary();
+  const txStr = toBase64(txBytes);
+  return txStr;
+};
+
+const context = { txHash: getTxHash(), txTime: new Date().toISOString() };
+const defaultAttrs = {
+  asset: {
+    moniker: 'test-asset',
+    data: { type: 'json', value: { purpose: 'test' } },
+    consumedTime: '',
+    issuer: '',
+    parent: '',
+    readonly: false,
+    transferrable: true,
+    ttl: 0,
+    tags: [],
+  },
+};
+['account', 'asset', 'delegation', 'factory', 'token', 'stake', 'rollup', 'rollupBlock', 'evidence'].forEach(
+  (table) => {
+    (statedb as any)[table].pre('create', function preCreate(this: any) {
+      const [address, attrs] = this;
+      const final =
+        attrs && (attrs.context || attrs.skipValidation)
+          ? attrs
+          : (states as any)[table].create({ address, ...Object.assign({}, (defaultAttrs as any)[table] || {}, attrs || {}) }, context);
+      this[1] = final;
+    });
+  }
+);
+
+export const prepareToken = async () => {
+  const tokenState = await statedb.token.get((defaultConfig as any).itx.address);
+  if (!tokenState) {
+    await statedb.token.create((defaultConfig as any).itx.address, (defaultConfig as any).itx);
+  }
+};
+
+export const prepareTx = async (type = 'default') => {
+  const sender = fromRandom(type as any);
+  const receiver = fromRandom(type as any);
+  const asset = fromRandom({ role: types.RoleType.ROLE_ASSET });
+
+  const accountAttrs = { balance: '0', tokens: { [(defaultConfig as any).itx.address]: '100000000000000000000' } };
+
+  await prepareToken();
+
+  await statedb.account.create(sender.address, accountAttrs);
+  await statedb.account.create(receiver.address, accountAttrs);
+  await statedb.asset.create(asset.address, { ...defaultAttrs.asset, owner: sender.address });
+
+  return { sender, receiver, asset, accountAttrs };
+};
+
+export const prepareGasPayer = async () => {
+  const gasPayer = fromRandom();
+  await statedb.account.create(gasPayer.address, {
+    tokens: { [(defaultConfig as any).itx.address]: fromTokenToUnit('10').toString() },
+  });
+  const stakeState = toStakeAddress(gasPayer.address, gasPayer.address);
+  await statedb.stake.create(stakeState, {
+    address: stakeState,
+    sender: gasPayer.address,
+    receiver: gasPayer.address,
+    message: 'stake-for-gas',
+    tokens: { [(defaultConfig as any).itx.address]: fromTokenToUnit('1').toString() },
+  });
+  return gasPayer;
+};
+
+export const getGasPayerHeader = async (txBuffer: Uint8Array) => {
+  const gasPayer = await prepareGasPayer();
+  return {
+    gasStakeHeaders: {
+      pk: toBase58(gasPayer.publicKey),
+      token: await JWT.sign(gasPayer.address, gasPayer.secretKey, { txHash: toTxHash(txBuffer) }),
+    },
+  };
+};
+
+export const getTransferTx = async ({ v2 = false } = {}) => {
+  const { sender, receiver, asset } = await prepareTx();
+  const method = v2 ? 'encodeTransferV2Tx' : 'encodeTransferTx';
+
+  const { object: txObject, buffer: txBuffer } = await getClient()[method]({
+    tx: {
+      itx: {
+        to: receiver.address,
+        value: await getClient().fromTokenToUnit(10),
+        assets: [asset.address],
+      },
+    },
+    wallet: sender,
+  });
+
+  return { txBase64: toBase64(txBuffer), txObject, txBuffer, sender, receiver, asset };
+};
+
+export const getSignedTransferTx = async ({ v2 = false } = {}) => {
+  const { sender, receiver, asset } = await prepareTx();
+  const method = v2 ? 'signTransferV2Tx' : 'signTransferTx';
+
+  const txObject = await getClient()[method]({
+    tx: {
+      itx: {
+        to: receiver.address,
+        value: await getClient().fromTokenToUnit(10),
+        assets: [asset.address],
+      },
+    },
+    wallet: sender,
+  });
+
+  const txBase64 = getTxBase64(txObject);
+  return { txObject, txBase64, sender, receiver, asset };
+};
+
+export const getSignedExchangeTx = async () => {
+  const { sender, receiver, asset } = await prepareTx();
+  const senderSigned = await getClient().signExchangeV2Tx({
+    tx: {
+      itx: {
+        to: receiver.address,
+        sender: {
+          assets: [asset.address],
+        },
+        receiver: {
+          value: await getClient().fromTokenToUnit(10),
+          assets: [],
+        },
+        data: {
+          typeUrl: 'json',
+          value: 'empty',
+        },
+      },
+    },
+    wallet: sender,
+  });
+
+  const receiverSigned = await getClient().multiSignExchangeV2Tx({
+    tx: cloneDeep(senderSigned),
+    wallet: receiver,
+    data: {
+      typeUrl: 'json',
+      value: 'empty',
+    },
+  });
+
+  const txBase64Sender = getTxBase64(senderSigned);
+  const txBase64Receiver = getTxBase64(receiverSigned);
+  return { sender, receiver, asset, senderSigned, receiverSigned, txBase64Sender, txBase64Receiver };
+};
+
+export const getAssetFactory = async ({
+  value = 10,
+  assets = [],
+  tokens = [],
+  hooks = [],
+  trustedIssuers = [],
+  limit = 0,
+  description = undefined as string | undefined,
+  output = undefined as any,
+} = {}) => ({
+  name: 'NodePurchaseFactory',
+  description: description || 'Purchase evidence of t2.small instance for 1 month',
+  settlement: 'instant',
+  limit,
+  trustedIssuers,
+  input: {
+    value: '0',
+    tokens: [
+      { address: (defaultConfig as any).itx.address, value: (await getClient().fromTokenToUnit(value)).toString() },
+      ...tokens,
+    ].filter((x: any) => x.value > 0),
+    assets: [...assets],
+    variables: [
+      {
+        name: 'name',
+        description: 'The name of the asset',
+        required: true,
+      },
+      {
+        name: 'description',
+        description: 'The name of the asset',
+        required: true,
+      },
+      {
+        name: 'counter',
+        description: 'The name of the asset',
+        required: true,
+      },
+    ],
+  },
+  output: output || {
+    issuer: '{{ctx.issuer.id}}',
+    parent: '{{ctx.factory}}',
+    moniker: 'NodePurchaseNFT',
+    readonly: true,
+    transferrable: true,
+    data: {
+      type: 'json',
+      value: {
+        type: '{{data.type}}',
+        period: '{{data.period}}',
+        name: '{{input.name}}',
+        description: '{{input.description}}',
+        counter: '{{input.counter}}',
+      },
+    },
+    endpoint: {
+      scope: 'public',
+      id: 'https://playground.abtwallet.io/api/nft/status',
+    },
+    display: {
+      type: 'url',
+      content: 'https://playground.abtwallet.io/api/nft/display',
+    },
+  },
+  data: {
+    type: 'json',
+    value: {
+      type: 't2.small',
+      period: '1 month',
+    },
+  },
+  hooks: [
+    {
+      name: 'postMint',
+      type: 'url',
+      hook: 'http://launcher.arcblock.io/api/purchases/{ctx.address}',
+    },
+  ].concat(hooks || []),
+});
+
+export const findTokenBalance = (state: any, field = 'tokens', token = (defaultConfig as any).itx.address) => {
+  if (!state[field]) {
+    return '0';
+  }
+
+  return fromUnitToToken(state[field][token] || '0', (defaultConfig as any).token.decimal);
+};
+
+export const ensureTokenBalanceBelow = (state: any, threshold: number, field = 'tokens', token = (defaultConfig as any).itx.address) => {
+  if (!state[field]) {
+    return true;
+  }
+
+  return toBN(state[field][token] || '0').lt(fromTokenToUnit(threshold, (defaultConfig as any).token.decimal));
+};
+
+export const declare = async (_client: any, sender: any, receiver?: any) => {
+  const wallet = receiver || fromRandom();
+  const c = _client || getClient();
+  const [hash] = await c.delegate({
+    from: sender,
+    to: wallet,
+    privileges: [
+      {
+        typeUrl: 'fg:t:exchange_v2',
+      },
+    ],
+  });
+  return { wallet, hash };
+};
+
+export const toBNStr = (n: number | string) => fromTokenToUnit(n, (defaultConfig as any).token.decimal).toString(10);
+export const fromBNStr = (n: string) => fromUnitToToken(n, (defaultConfig as any).token.decimal);
+
+export const getRollupConfig = () => ({
+  paused: false,
+  closed: false,
+  tokenAddress: (defaultConfig as any).itx.address,
+  vaultAddress: '0x9c41b8E8500aEAE3A376a52E6F7547AFe6A92eB1',
+  contractAddress: '0x9c41b8E8500aEAE3A376a52E6F7547AFe6A92eB1',
+  minStakeAmount: toBNStr(1000000),
+  maxStakeAmount: toBNStr(10000000),
+  minSignerCount: 2,
+  maxSignerCount: 3,
+  minBlockSize: 1,
+  maxBlockSize: 10,
+  minBlockInterval: 1, // 1 seconds
+  minBlockConfirmation: 1,
+  minDepositAmount: toBNStr(100),
+  minWithdrawAmount: toBNStr(100),
+  maxDepositAmount: toBNStr(100000),
+  maxWithdrawAmount: toBNStr(100000),
+  depositFeeRate: 100, // 1%
+  withdrawFeeRate: 100, // 1%
+  proposerFeeShare: 6000, // 60%
+  publisherFeeShare: 3000, // 30%
+  minDepositFee: toBNStr(10),
+  maxDepositFee: toBNStr(10000),
+  minWithdrawFee: toBNStr(10),
+  maxWithdrawFee: toBNStr(10000),
+  blockHeight: 0,
+  leaveWaitingPeriod: 60,
+  publishWaitingPeriod: 60,
+  publishSlashRate: 10, // 0.1%
+});
+
+export const sleep = (timeout: number) =>
+  new Promise<void>((resolve) => {
+    setTimeout(resolve, timeout);
+  });
+
+export const generateSvg = (maxSize: number) => {
+  const header = '<svg xmlns="http://www.w3.org/2000/svg" width="100" height="100">';
+  const footer = '</svg>';
+
+  const baseSize = Buffer.byteLength(header + footer, 'utf8');
+  if (maxSize <= baseSize) return header + footer;
+
+  const availableSpace = maxSize - baseSize;
+  const filler = '<g />';
+  const fillerSize = Buffer.byteLength(filler, 'utf8');
+
+  const count = Math.floor(availableSpace / fillerSize);
+  const content = filler.repeat(count);
+
+  return header + content + footer;
+};
+
+export const gasVault = fromRandom();
+export const feeVault = fromRandom();
+
+export const config: any = {
+  ...defaultConfig,
+  vaults: {
+    ...(defaultConfig as any).vaults,
+    txGas: [gasVault.address],
+    txFee: feeVault.address,
+  },
+  token: { ...(defaultConfig as any).token, address: (defaultConfig as any).itx.address },
+};
+
+export const gasVaultAddress = config.vaults.txGas[0];
+export const feeVaultAddress = config.vaults.txFee;
+
+statedb.account.create(config.vaults.txFee, { tokens: { [config.itx.address]: '0' } });
+statedb.account.create(config.vaults.slashedStake, { tokens: { [config.itx.address]: '0' } });
+config.vaults.txGas.forEach((x: string) => {
+  statedb.account.create(x, { tokens: { [config.itx.address]: toBNStr(10000) } });
+});
+
+export const prepareTokenFactory = (props: any = {}) => {
+  const { token, ...rest } = props;
+  const name = crypto.randomUUID().substring(0, 8);
+  const itx: any = {
+    feeRate: 500, // 5% fee
+    token: {
+      name,
+      description: 'create token factory description',
+      decimal: 18,
+      symbol: name.substring(0, 6).toUpperCase(),
+      unit: 'D',
+      icon: '',
+      website: 'https://www.arcblock.com',
+      type: 'BondingCurveToken',
+      metadata: {
+        type: 'json',
+        value: {
+          issuer: 'arcblock',
+          communityUrl: 'https://www.arcblock.com',
+        },
+      },
+      ...token,
+    },
+    curve: {
+      type: 'constant',
+      fixedPrice: toBNStr('1'),
+    },
+    reserveAddress: config.token.address,
+    data: null,
+    ...rest,
+  };
+
+  itx.token.address = token?.address || toTokenAddress(itx.token);
+  itx.address = rest?.address || toTokenFactoryAddress(itx);
+
+  return itx;
+};
+
+export const createTokenFactoryStake = async ({ sender, nonce, amount = 100, tokens = null, ...props }: any = {}) => {
+  // For token factory creation, receiver should be config.token.address
+  const receiver = config.token.address;
+  const stakeAddress = toStakeAddress(sender.address, receiver, nonce);
+  const stakeTokens = tokens || { [config.token.address]: toBNStr(amount) };
+
+  const stakeState = await statedb.stake.get(stakeAddress);
+
+  await statedb.stake.updateOrCreate(stakeState, {
+    nonce,
+    address: stakeAddress,
+    sender: sender.address,
+    receiver,
+    message: 'test stake for token creation',
+    tokens: stakeTokens,
+    ...props,
+  });
+
+  return { stakeAddress };
+};
+
+export const mockWebsiteVC = (subject: any, issuer: any, options: any = {}) => {
+  spyOn(global, 'fetch').mockImplementation(((url: any, ...rest: any[]) => {
+    if (!url.includes('/ocap/tokens.json')) {
+      return (globalThis as any).require('node-fetch-commonjs')(url, ...rest);
+    }
+
+    return Promise.resolve({
+      ok: true,
+      json: async () => {
+        if (!subject) return options.credentials || null;
+
+        const vc = await createVC({
+          type: options.type || 'TokenIssueCredential',
+          issuer: {
+            name: options.issuerName || 'Create Token',
+            wallet: issuer,
+          },
+          subject,
+        });
+        return options.credentials || [vc];
+      },
+    } as any);
+  }) as any);
+};
+
+export const executeTx = (tx: any, withTxHash = false, _statedb: any = {}, options: any = {}) => {
+  const { runAsLambda, withGasPayer, config: _config, ...extraCtx } = options;
+
+  return new Promise(async (resolve) => {
+    const ctx: any = {
+      txBase64: getTxBase64(tx),
+      config: _config || config,
+      statedb: { ...statedb, ..._statedb },
+      ...extraCtx,
+    };
+
+    if (withGasPayer) {
+      const typeUrl = fromTypeUrl(tx.itx.typeUrl);
+      const { buffer: txBuffer } = await getClient()[`encode${typeUrl}`]({ tx });
+      ctx.extra = {
+        ...(ctx.extra || {}),
+        ...(await getGasPayerHeader(txBuffer)),
+      };
+    }
+
+    (runAsLambda ? lambdaExecutor.execute : execute)(ctx, (err: any) => {
+      resolve(withTxHash ? { err, txHash: ctx.txHash } : err);
+    });
+  });
+};
+
+export const createTokenFactory = async (owner: any, props: any, { subject, stakeAddress, config: _config, ...rest }: any = {}) => {
+  const itx = prepareTokenFactory(props);
+
+  // stake for token creation
+  let _stakeAddress = stakeAddress;
+  if (_stakeAddress == null) {
+    ({ stakeAddress: _stakeAddress } = await createTokenFactoryStake({ sender: owner, nonce: itx.token.symbol }));
+  }
+
+  // mock for website verification
+  mockWebsiteVC(
+    subject || {
+      id: owner.address,
+      issued: {
+        address: itx.token.address,
+        symbol: itx.token.symbol,
+        website: itx.token.website,
+        chainId: (_config || config).chainId,
+      },
+    },
+    owner
+  );
+
+  const tx = await getClient().signCreateTokenFactoryTx({ tx: { itx }, wallet: owner, ...rest });
+  const err = await executeTx(tx, false, {}, { withGasPayer: true, config: _config || config });
+
+  const tokenFactoryState = await statedb.tokenFactory.get(itx.address);
+
+  return {
+    itx,
+    err,
+    tokenFactoryState,
+    stakeAddress: _stakeAddress,
+  };
+};
+
+// Re-export for convenience
+export { toBN, toTxHash };