tunnckoCore

Motivation and how the process currently works

The current approach is that a user escrows their Ethscriptions to a Marketplace contract that uses the ESIP-2 (contract-based transfers) for transferring when a sale happens. That escrowing process is required, and thankfully tho can be just a one-time cheap thing through the ESIP-5 Bulk transfers. While i was working on indexer, there was few people that transferred over 3000 ethscriptions at one go, for just a few dollars, and that was pre-Blobs with medium to high gas fees. Now would probably be just few cents.

The listing process is not "on-chain", the user just makes a listing through a marketplace site, that listing goes in a database and shows it to other marketplace users. When a user wants to buy, it actually calls the market's' contract with specific "listing id", the "ethscription id" which wants to buy, and the price asked by the seller. All that happens under the hood and is not complex to the end user. Nothing bad in all that.

The other side

tunnckoCore

// SPDX-License-Identifier: Apache-2.0

// RFC 4648 base32 alphabet without pad
export const BASE32_ALPHABET = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ234567';

/**
 * Generate secret
 * @param length optional, length (defaults to `24`)
 * @returns secret
 */

tunnckoCore

import { english, generateMnemonic, mnemonicToAccount } from "viem/accounts";
import { sepolia } from "viem/chains";
import { createFacetClient } from "./index.ts";

const mnemonic = generateMnemonic(english, 256);
const account = mnemonicToAccount(mnemonic);

const facet = createFacetClient({
  account,
  chain: sepolia,

tunnckoCore

Just import and call trackBlobs(handler).

import { trackBlobs, onlyDataURIBlobs } from './pkg';

await trackBlobs(({ parentBlockSlotHash, block, blobTransactions, blobs }) => {
  const { dataBytes } = onlyDataURIBlobs({ blobs });
 

tunnckoCore

import { bytesToString, hexToBytes } from 'viem';

export async function getBlobMeta(hash) {
	let result = {};

	try {
		const res = await fetch(getBlobUrl(hash)).then((x) => x.json());

		if (res.error) {
			result.error = res.error;

tunnckoCore

function getAttribute(obj: any, key: any) {
  const parts = key.split(".");

  for (let _i = 0, parts_1 = parts; _i < parts_1.length; _i++) {
    const k = parts_1[_i];

    if (obj !== null && typeof obj === "object" && k in obj) {
      obj = obj[k];
    } else {
      obj = undefined;

tunnckoCore

// SPDX-License-Identifier: AGPL-3.0-only
pragma solidity >=0.8.21;

// Author: wgw.eth / wgw.lol / tunnckoCore
// Date: August 2023

contract EthsBidding {
  struct Offer {
    bytes32 bidTxHash;
    bytes32 ethscriptionId;

tunnckoCore

import { verifyMessage } from "viem";

/**
 * Ethscriptions Hosting & Resolving of ens domains & ethscriptions handles eg. `data,hirsch`
 *
 * `data:application/vnd.esc.wgw.deploy.`
 * -> hex = 646174613a6170706c69636174696f6e2f766e642e6573632e7767772e6465706c6f792e
 *
 * `+json`
 * -> hex = 2b6a736f6e

tunnckoCore

[
  {
    "hex": "#f0f8ff",
    "name": "aliceblue"
  },
  {
    "hex": "#faebd7",
    "name": "antiquewhite"
  },
  {

tunnckoCore

New (old) Way of Trading.

I think I solved the problem of safe #Ethscriptions trading.

A multi step process, but safe and sane. Basically, offers-based.

---

1/ Here's how it could work: