Merge branch 'latest' into joinInternalCreate

master
cyl19970726 2 years ago
commit e750e5b2b0

2
.gitignore vendored

@ -131,3 +131,5 @@ dist
.DS_Store .DS_Store
bin/ bin/
dist/ dist/
cache.json

@ -38,7 +38,9 @@
"pkg:all": "yarn pkg:git3 && yarn pkg:git-remote", "pkg:all": "yarn pkg:git3 && yarn pkg:git-remote",
"pkg": "yarn build && yarn pkg:all", "pkg": "yarn build && yarn pkg:all",
"install-mac": "yarn pkg && cp bin/git3-macos /usr/local/bin/git3 && cp bin/git-remote-git3-macos /usr/local/bin/git-remote-git3", "install-mac": "yarn pkg && cp bin/git3-macos /usr/local/bin/git3 && cp bin/git-remote-git3-macos /usr/local/bin/git-remote-git3",
"install-linux": "yarn pkg && cp bin/git3-linux /usr/local/bin/git3 && cp bin/git-remote-git3-linux /usr/local/bin/git-remote-git3" "install-linux": "yarn pkg && cp bin/git3-linux /usr/local/bin/git3 && cp bin/git-remote-git3-linux /usr/local/bin/git-remote-git3",
"sync": "ts-node src/scripts/sync.ts",
"clear-sync": "ts-node src/scripts/clear.ts"
}, },
"devDependencies": { "devDependencies": {
"@types/buffer-split": "^1.0.0", "@types/buffer-split": "^1.0.0",
@ -47,6 +49,7 @@
"@types/node": "^18.11.18", "@types/node": "^18.11.18",
"@types/parse-git-config": "^3.0.1", "@types/parse-git-config": "^3.0.1",
"@types/url-parse": "^1.4.8", "@types/url-parse": "^1.4.8",
"es-main": "^1.2.0",
"esbuild": "^0.17.0", "esbuild": "^0.17.0",
"pkg": "^5.8.0", "pkg": "^5.8.0",
"ts-node": "^10.9.1", "ts-node": "^10.9.1",

@ -6,6 +6,7 @@ import { getWallet, randomRPC, setupContract } from "./wallet.js"
import Url from "url-parse" import Url from "url-parse"
import network from "../config/evm-network.js" import network from "../config/evm-network.js"
import abis from "../config/abis.js" import abis from "../config/abis.js"
import { TxManager } from "./tx-manager.js"
export type Git3Protocol = { export type Git3Protocol = {
sender: string sender: string
@ -20,23 +21,37 @@ export type Git3Protocol = {
ns?: Record<string, any> ns?: Record<string, any>
nsName?: string nsName?: string
nsDomain?: string nsDomain?: string
factory?: ethers.Contract
} }
type Option = { export type ParseOption = {
skipRepoName?: boolean skipRepoName?: boolean
ignoreProtocolHeader?: boolean ignoreProtocolHeader?: boolean
includeFactory?: boolean
}
export function initNameService(): ethers.Contract {
let nsContract = setupContract(
new ethers.providers.JsonRpcProvider("https://goerli-rollup.arbitrum.io/rpc"),
nameServices.resolver_,
abis.NameService
)
return nsContract
} }
export async function parseGit3URI( export async function parseGit3URI(
uri: string, uri: string,
option: Option = { skipRepoName: false, ignoreProtocolHeader: false } option: ParseOption = {
skipRepoName: false,
ignoreProtocolHeader: false,
includeFactory: false,
}
): Promise<Git3Protocol> { ): Promise<Git3Protocol> {
if (option.ignoreProtocolHeader) { if (option.ignoreProtocolHeader) {
if (!uri.startsWith("git3://")) { if (!uri.startsWith("git3://")) {
uri = "git3://" + uri uri = "git3://" + uri
} }
} }
console.error("uri", uri)
const url = new Url(uri) const url = new Url(uri)
let sender = url.username || "default" let sender = url.username || "default"
let chainId = url.port ? parseInt(url.port) : null let chainId = url.port ? parseInt(url.port) : null
@ -60,12 +75,7 @@ export async function parseGit3URI(
chainId = chainId || ns.chainId chainId = chainId || ns.chainId
// Todo: temporary resolve name service // Todo: temporary resolve name service
let resolverAddress = ns["resolver"] let nsContract = initNameService()
let nsContract = setupContract(
new ethers.providers.JsonRpcProvider("https://goerli-rollup.arbitrum.io/rpc"),
resolverAddress,
abis.NameService
)
hubAddress = await nsContract.nameHub([nsName, nsDomain].join(".")) hubAddress = await nsContract.nameHub([nsName, nsDomain].join("."))
if (hubAddress == "0x0000000000000000000000000000000000000000") if (hubAddress == "0x0000000000000000000000000000000000000000")
throw new Error(`${nsName} not found`) throw new Error(`${nsName} not found`)
@ -97,6 +107,11 @@ export async function parseGit3URI(
let hub = setupContract(provider, hubAddress, abi, wallet) let hub = setupContract(provider, hubAddress, abi, wallet)
wallet = wallet.connect(hub.provider) wallet = wallet.connect(hub.provider)
let factory
if (option.includeFactory) {
factory = setupContract(provider, netConfig.contracts.factory, abis.Factory, wallet)
}
return { return {
sender, sender,
senderAddress, senderAddress,
@ -110,5 +125,40 @@ export async function parseGit3URI(
ns, ns,
nsName, nsName,
nsDomain, nsDomain,
factory,
}
}
export type FactoryProtocol = {
factory: ethers.Contract
txManager: TxManager
netConfig: Record<string, any>
chainId: number
}
export async function initFactoryByChainID(
chain: string,
wallet: ethers.Wallet | null
): Promise<FactoryProtocol> {
let netConfig, chainId
chainId = parseInt(chain)
if (chainId) {
netConfig = network[chainId]
} else {
let ns = nameServices[chain]
if (!ns) throw new Error(`invalid name service ${chain}`)
chainId = ns.chainId
netConfig = network[chainId]
}
let rpc = randomRPC(netConfig.rpc)
const provider = new ethers.providers.JsonRpcProvider(rpc)
let factory = setupContract(provider, netConfig.contracts.factory, abis.Factory, wallet)
let txManager = new TxManager(factory, chainId, netConfig.txConst)
return {
factory,
txManager,
netConfig,
chainId,
} }
} }

File diff suppressed because one or more lines are too long

@ -89,7 +89,7 @@ const evmNetworks: Record<number, any> = {
txConst: { txConst: {
blockTimeSec: 7, blockTimeSec: 7,
}, },
contracts: { factory: "0x9f0a56c4b11b6f65454C205b79C91424B5C6d590" }, contracts: { factory: "0x5f0f1eb909dE5F9EF48C154F61b2FEB8fd3dA53f" },
}, },
421613: { 421613: {
name: "Arbitrum - Goerli", name: "Arbitrum - Goerli",
@ -114,7 +114,7 @@ const evmNetworks: Record<number, any> = {
rbfTimes: 5, rbfTimes: 5,
boardcastTimes: 10, boardcastTimes: 10,
}, },
contracts: { factory: "0x51bb7F23193b88696D25EAec7E3293a2C96e55Ee" }, contracts: { factory: "0xa709975Bc01e745432f8898499E7b9a60f420117" },
}, },
} }

@ -1,15 +1,13 @@
const ns: Record<string, any> = { const ns: Record<string, any> = {
resolver_: "0xd684DBf9124d6B1f74f37558dD11fdcE0103AF15",
w3q: { w3q: {
chainId: 3334, chainId: 3334,
resolver: "0x372343Dd5274bb7B571F81d4FBA3bC0E28FeF3D9",
}, },
arb: { arb: {
chainId: 42170, chainId: 42170,
resolver: "0x372343Dd5274bb7B571F81d4FBA3bC0E28FeF3D9",
}, },
arbg: { arbg: {
chainId: 421613, chainId: 421613,
resolver: "0x372343Dd5274bb7B571F81d4FBA3bC0E28FeF3D9",
}, },
} }

@ -5,11 +5,9 @@ import bip39 from "bip39"
import inquirer from "inquirer" import inquirer from "inquirer"
import { importActions, generateActions,createHubActions,HubMemberActions } from "./actions.js" import { importActions, generateActions,createHubActions,HubMemberActions } from "./actions.js"
import network from "../config/evm-network.js" import network from "../config/evm-network.js"
import { explorerTxUrl, getWallet, randomRPC, setupContract } from "../common/wallet.js" import { explorerTxUrl, getWallet, randomRPC } from "../common/wallet.js"
import { parseGit3URI } from "../common/git3-protocol.js" import { initFactoryByChainID, parseGit3URI } from "../common/git3-protocol.js"
import { TxManager } from "../common/tx-manager.js" import { TxManager } from "../common/tx-manager.js"
import nameServices from "../config/name-services.js"
import abis from "../config/abis.js"
const program = new Command() const program = new Command()
@ -180,31 +178,18 @@ hub
let isPermissionless = permissionless === "yes"? true:false let isPermissionless = permissionless === "yes"? true:false
console.log(`creating hub with permissionless:${isPermissionless} ...`) console.log(`creating hub with permissionless:${isPermissionless} ...`)
let netConfig, chainId
chainId = parseInt(chain)
if (chainId) {
netConfig = network[chainId]
} else {
let ns = nameServices[chain]
if (!ns) throw new Error(`invalid name service ${chain}`)
chainId = ns.chainId
netConfig = network[chainId]
}
const wallet = await getWallet() const wallet = await getWallet()
let rpc = randomRPC(netConfig.rpc) let protocol = await initFactoryByChainID(chain, wallet)
const provider = new ethers.providers.JsonRpcProvider(rpc)
let factory = setupContract(provider, netConfig.contracts.factory, abis.Factory, wallet) let receipt = await protocol.txManager.SendCall("createHub", [isPermissionless])
let txManager = new TxManager(factory, chainId, netConfig.txConst)
let receipt = await txManager.SendCall("createHub", [isPermissionless])
// let CreateHubEvent = factory.interface.getEvent("CreateHub"); // let CreateHubEvent = factory.interface.getEvent("CreateHub");
console.log(explorerTxUrl(receipt.transactionHash, netConfig.explorers)) console.log(explorerTxUrl(receipt.transactionHash, protocol.netConfig.explorers))
let events = receipt.logs let events = receipt.logs
.map((log: any) => { .map((log: any) => {
try { try {
return factory.interface.parseLog(log) return protocol.factory.interface.parseLog(log)
} catch (e) { } catch (e) {
return null return null
} }
@ -420,7 +405,7 @@ repo
repo repo
.command("members") .command("members")
.argument("<uri>","ex: git3.w3q/repo_name or hub_addr:chainid/repo_name") .argument("<uri>", "ex: git3.w3q/repo_name or hub_addr:chainid/repo_name")
.description("get all members information of the repository") .description("get all members information of the repository")
.action(async (uri) => { .action(async (uri) => {
let protocol = await parseGit3URI(uri, { ignoreProtocolHeader: true, skipRepoName: true }) let protocol = await parseGit3URI(uri, { ignoreProtocolHeader: true, skipRepoName: true })
@ -438,17 +423,23 @@ repo
.action(async (conAddr,options) => { .action(async (conAddr,options) => {
let protocol = await parseGit3URI(options.uri, { ignoreProtocolHeader: true, skipRepoName: true }) let protocol = await parseGit3URI(options.uri, { ignoreProtocolHeader: true, skipRepoName: true })
let owner = await protocol.hub.repoOwner(Buffer.from(protocol.repoName)) let owner = await protocol.hub.repoOwner(Buffer.from(protocol.repoName))
if (owner != protocol.wallet.address){ if (owner != protocol.wallet.address) {
let hubName = protocol.ns let hubName = protocol.ns
? `${protocol.nsName}.${protocol.nsDomain}` ? `${protocol.nsName}.${protocol.nsDomain}`
: protocol.hubAddress : protocol.hubAddress
console.error(`[repo addContributor] can only be executed with the owner authority of this repository:${protocol.repoName}-hub:${hubName}`) console.error(
`[repo addContributor] can only be executed with the owner authority of this repository:${protocol.repoName}-hub:${hubName}`
)
} }
const txManager = new TxManager(protocol.hub, protocol.chainId, protocol.netConfig.txConst) const txManager = new TxManager(protocol.hub, protocol.chainId, protocol.netConfig.txConst)
let receipt = await txManager.SendCall("addRepoContributor", [Buffer.from(protocol.repoName),conAddr]) let receipt = await txManager.SendCall("addRepoContributor", [
Buffer.from(protocol.repoName),
conAddr,
])
console.log(explorerTxUrl(receipt.transactionHash, protocol.netConfig.explorers)) console.log(explorerTxUrl(receipt.transactionHash, protocol.netConfig.explorers))
}) })
repo repo
.command("remove-member") .command("remove-member")
.argument("<con addr>","contributor address") .argument("<con addr>","contributor address")
@ -457,17 +448,23 @@ repo
.action(async (conAddr,options) => { .action(async (conAddr,options) => {
let protocol = await parseGit3URI(options.uri, { ignoreProtocolHeader: true, skipRepoName: true }) let protocol = await parseGit3URI(options.uri, { ignoreProtocolHeader: true, skipRepoName: true })
let owner = await protocol.hub.repoOwner(Buffer.from(protocol.repoName)) let owner = await protocol.hub.repoOwner(Buffer.from(protocol.repoName))
if (owner != protocol.wallet.address){ if (owner != protocol.wallet.address) {
let hubName = protocol.ns let hubName = protocol.ns
? `${protocol.nsName}.${protocol.nsDomain}` ? `${protocol.nsName}.${protocol.nsDomain}`
: protocol.hubAddress : protocol.hubAddress
console.error(`[repository removeContributor] can only be executed with the owner authority of this repository:${protocol.repoName}-hub:${hubName}`) console.error(
`[repository removeContributor] can only be executed with the owner authority of this repository:${protocol.repoName}-hub:${hubName}`
)
} }
const txManager = new TxManager(protocol.hub, protocol.chainId, protocol.netConfig.txConst) const txManager = new TxManager(protocol.hub, protocol.chainId, protocol.netConfig.txConst)
let receipt = await txManager.SendCall("removeRepoContributor", [Buffer.from(protocol.repoName),conAddr]) let receipt = await txManager.SendCall("removeRepoContributor", [
Buffer.from(protocol.repoName),
conAddr,
])
console.log(explorerTxUrl(receipt.transactionHash, protocol.netConfig.explorers)) console.log(explorerTxUrl(receipt.transactionHash, protocol.netConfig.explorers))
}) })
// Todo: set-wallet temporarily useless // Todo: set-wallet temporarily useless
// program // program
// .command("set-wallet") // .command("set-wallet")

@ -0,0 +1,10 @@
import { api, deleteHub } from "./sync.js"
import fs from "fs"
fs.unlinkSync("./cache.json")
let res = await api.get("/orgs")
for (const org of res.data) {
console.log("hub:", org.name)
deleteHub(org.name)
}

@ -0,0 +1,276 @@
import {
FactoryProtocol,
initFactoryByChainID,
initNameService,
parseGit3URI,
} from "../common/git3-protocol.js"
import network from "../config/evm-network.js"
import { readFileSync, writeFileSync, existsSync } from "fs"
import { ethers } from "ethers"
import axios from "axios"
import nameServices from "../config/name-services.js"
import { Retrier } from "../common/queue-task.js"
let cache = loadCache()
export let api = axios.create({
baseURL: `http://127.0.0.1:${process.env.port || 3331}/api/v1/`,
responseType: "json",
headers: {
"Content-Type": "application/json",
Authorization: `token ${process.env.TOKEN}`,
},
validateStatus: function (status) {
return status < 500
},
})
function loadCache() {
existsSync("./cache.json") || writeFileSync("./cache.json", "")
let text = readFileSync("./cache.json").toString()
if (text == "") {
return {
factory: {
3334: {
start: 5375112,
last: 5375112,
},
421613: {
start: 9341366,
last: 9341366,
},
},
hubs: {},
ns: {
start: 9340900,
last: 9340900,
nameHub: {},
hubName: {},
},
}
} else {
return JSON.parse(text)
}
}
function saveCache(cache: any) {
writeFileSync("./cache.json", JSON.stringify(cache))
}
const RANGE = 1000
const WAIT_SECONDS = 10
async function eventIterator(
contract: ethers.Contract,
filters: any[],
last: number,
saveLastCallback: (_last: number) => void,
eventCallback: (event: any) => void,
stop: () => boolean = () => false
) {
let provider = contract.provider
while (true) {
if (stop && stop()) break
let lastBlock = await Retrier(async () => await provider.getBlockNumber(), { maxRetry: 10 })
for (let i = last; i < lastBlock; i += RANGE) {
let end = i + RANGE - 1
if (end >= lastBlock) end = lastBlock - 1
console.log(i, end)
for (const filter of filters) {
let events = await Retrier(async () => await contract.queryFilter(filter, i, end), {
maxRetry: 10,
})
for (const event of events) {
await eventCallback(event)
//console.log(protocol.chainId, i, end, event.args, event)
}
}
last = end
saveLastCallback(last)
}
await new Promise((resolve) => setTimeout(resolve, WAIT_SECONDS * 1000))
}
}
async function syncFactory(protocol: FactoryProtocol) {
let factory = protocol.factory
let last = cache.factory[protocol.chainId].last
console.log("syncFactory", protocol.chainId, last)
await eventIterator(
factory,
[factory.filters.CreateHub()],
last,
(_last) => {
cache.factory[protocol.chainId].last = _last
saveCache(cache)
},
async (event) => {
let hubAddr = event.args!.hub
if (cache.ns.hubName[hubAddr]) {
hubAddr = cache.ns.hubName[hubAddr]
} else {
hubAddr = `${hubAddr}:${protocol.chainId}`
}
console.log("hub:", hubAddr, "block:", event.blockNumber)
await createHub(hubAddr)
syncHub(hubAddr, event.blockNumber)
}
)
}
function Hex0xToStr(hex0x: string) {
return Buffer.from(hex0x.slice(2), "hex").toString()
}
async function syncHub(hubAddr: string, start: number) {
if (start > 0) {
cache.hubs[hubAddr] = { start, last: start }
}
let protocol = await parseGit3URI(hubAddr, { skipRepoName: true, ignoreProtocolHeader: true })
let hub = protocol.hub
let last = cache.hubs[hubAddr].last
await eventIterator(
hub,
[hub.filters.RepoCreated(), hub.filters.SetRepoRef()],
last,
(_last) => {
if (cache.hubs[hubAddr]) {
cache.hubs[hubAddr].last = _last
saveCache(cache)
}
},
async (event) => {
if (event.event == "RepoCreated") {
let repoName = Hex0xToStr(event.args!.repoName)
console.log("repo:", hubAddr, repoName)
await mirrorRepo(hubAddr, repoName)
} else if (event.event == "SetRepoRef") {
let repoName = Hex0xToStr(event.args!.repoName)
await pullRepo(hubAddr, repoName)
}
},
() => {
return !cache.hubs[hubAddr]
}
)
}
async function mirrorRepo(hubAddr: string, repoName: string) {
let uri = `git3://${hubAddr}/${repoName}`
let res = await api.post("/repos/migrate", {
clone_addr: uri,
mirror: true,
mirror_interval: "1h",
private: false,
repo_name: repoName,
repo_owner: hubAddr,
service: "git",
uid: 0,
})
console.log("mirrorRepo", uri, res.status)
}
async function pullRepo(hubAddr: string, repoName: string) {
let uri = `git3://${hubAddr}/${repoName}`
let res = await api.post(`/repos/${hubAddr}/${repoName}/mirror-sync`)
console.log("pullRepo", uri, res.status)
}
async function migrateHub(oldHubAddr: string, newHubAddr: string) {
console.log("migrateHub:", oldHubAddr, newHubAddr)
let oldHub = cache.hubs[oldHubAddr]
if (oldHub) {
deleteHub(oldHubAddr)
delete cache.hubs[oldHubAddr]
await createHub(newHubAddr)
syncHub(newHubAddr, oldHub.start)
} else {
await createHub(newHubAddr)
}
}
async function syncNameService() {
let nsContract = initNameService()
let last = cache.ns.last
await eventIterator(
nsContract,
[nsContract.filters.RegisterHub()],
last,
(_last) => {
cache.ns.last = _last
saveCache(cache)
},
async (event) => {
let name = event.args!.name
let hub = event.args!.hub
let [_, nsDomain] = name.split(".")
let ns = nameServices[nsDomain]
let hubAddr = `${hub}:${ns.chainId}`
let old = cache.ns.nameHub[name]
if (!old) {
await migrateHub(hubAddr, name)
} else {
if (old != hub) {
// Rebind NS hub address
delete cache.ns.hubName[old]
await migrateHub(name, name)
} else {
// same name, do nothing
}
}
console.log("ns:", name, hub)
cache.ns.nameHub[name] = hub
cache.ns.hubName[hub] = name
saveCache(cache)
}
)
}
export async function deleteHub(hubAddr: string): Promise<boolean> {
let res = await api.get(`/orgs/${hubAddr}/repos`, { params: { page: 1, limit: 100000 } })
if (res.status != 200) {
return false
}
for (const repo of res.data) {
res = await api.delete(`/repos/${hubAddr}/${repo.name}`)
console.log("delete repo:", `${hubAddr}/${repo.name}`)
}
res = await api.delete(`/orgs/${hubAddr}`)
console.log(res.status, res.data)
return res.status == 200
}
async function createHub(hubAddr: string) {
let res = await api.post(`/orgs`, {
repo_admin_change_team_access: true,
username: hubAddr,
visibility: "public",
})
if (res.status != 201) {
console.log("[ERROR] createHub", hubAddr, res.status, res.data)
}
return res.status == 201
}
async function main() {
let tasks = []
tasks.push(syncNameService())
for (const [chainId, _] of Object.entries(network)) {
let protocol = await initFactoryByChainID(chainId, null)
tasks.push(syncFactory(protocol))
}
for (const [hubAddr, _] of Object.entries(cache.hubs)) {
tasks.push(syncHub(hubAddr, 0))
}
await Promise.all(tasks)
}
import esMain from "es-main"
if (esMain(import.meta)) {
main()
}

@ -2,8 +2,6 @@ import { Ref, Status, Storage } from "./storage.js"
import { ethers } from "ethers" import { ethers } from "ethers"
import { TxManager } from "../common/tx-manager.js" import { TxManager } from "../common/tx-manager.js"
import { Git3Protocol } from "../common/git3-protocol.js" import { Git3Protocol } from "../common/git3-protocol.js"
import { buffer } from "stream/consumers"
export class ETHStorage implements Storage { export class ETHStorage implements Storage {
repoName: string repoName: string
@ -41,60 +39,69 @@ export class ETHStorage implements Storage {
async upload(path: string, file: Buffer): Promise<Status> { async upload(path: string, file: Buffer): Promise<Status> {
try { try {
let chunks: Buffer[] = []; let chunks: Buffer[] = []
let costs:number[] = []; let costs: number[] = []
const FileChunkSize = 475 * 1024 const FileChunkSize = 475 * 1024
const perEthPayStorageSize = 24 * 1024 const perEthPayStorageSize = 24 * 1024
const initCodeLen = 280; const initCodeLen = 280
if (file.length > FileChunkSize) { if (file.length > FileChunkSize) {
let uploadedSize = 0; let uploadedSize = 0
let nouploadfileSize = file.length; let nouploadfileSize = file.length
for (uploadedSize = 0; uploadedSize < file.length; uploadedSize += FileChunkSize) { for (uploadedSize = 0; uploadedSize < file.length; uploadedSize += FileChunkSize) {
let newchunk:Buffer; let newchunk: Buffer
let cost:number; let cost: number
if (file.length != nouploadfileSize + uploadedSize){ if (file.length != nouploadfileSize + uploadedSize) {
throw new Error(`file.length${file.length} != nouploadfileSize${nouploadfileSize} + uploadedSize${uploadedSize}`) throw new Error(
} `file.length${file.length} != nouploadfileSize${nouploadfileSize} + uploadedSize${uploadedSize}`
if (nouploadfileSize < FileChunkSize){ )
}
if (nouploadfileSize < FileChunkSize) {
newchunk = Buffer.alloc(nouploadfileSize) newchunk = Buffer.alloc(nouploadfileSize)
file.copy(newchunk, 0,uploadedSize,file.length) file.copy(newchunk, 0, uploadedSize, file.length)
cost = Math.ceil((nouploadfileSize+ initCodeLen) / perEthPayStorageSize) cost = Math.ceil((nouploadfileSize + initCodeLen) / perEthPayStorageSize)
}else{ } else {
newchunk = Buffer.alloc(FileChunkSize) newchunk = Buffer.alloc(FileChunkSize)
file.copy(newchunk, 0,uploadedSize,uploadedSize+FileChunkSize) file.copy(newchunk, 0, uploadedSize, uploadedSize + FileChunkSize)
cost = Math.ceil((FileChunkSize+initCodeLen) / perEthPayStorageSize) cost = Math.ceil((FileChunkSize + initCodeLen) / perEthPayStorageSize)
nouploadfileSize -= FileChunkSize; nouploadfileSize -= FileChunkSize
} }
chunks.push(newchunk); chunks.push(newchunk)
costs.push(cost); costs.push(cost)
} }
chunks.forEach(async (context,index) => { chunks.forEach(async (context, index) => {
console.error(`=== uploading file chunk ${path} chunkId-${index} chunk_size:${context.length} storage_cost:${costs[index]}-token===`) console.error(
`=== uploading file chunk ${path} chunkId-${index} chunk_size:${context.length} storage_cost:${costs[index]}-token===`
)
await this.txManager.SendCall("uploadChunk", [ await this.txManager.SendCall("uploadChunk", [
Buffer.from(this.repoName), Buffer.from(this.repoName),
Buffer.from(path), Buffer.from(path),
index, index,
context, context,
{value:ethers.utils.parseEther(costs[index].toString())}, { value: ethers.utils.parseEther(costs[index].toString()) },
]); ])
console.error(`=== upload file chunk ${path} chunkId-${index} chunk_size:${context.length} storage_cost:${costs[index]}-token Succeed===`) console.error(
`=== upload file chunk ${path} chunkId-${index} chunk_size:${context.length} storage_cost:${costs[index]}-token Succeed===`
)
}) })
} else { } else {
let cost:number = 0; let cost: number = 0
if (file.length > perEthPayStorageSize){ if (file.length > perEthPayStorageSize) {
cost = Math.ceil(file.length / perEthPayStorageSize); cost = Math.ceil(file.length / perEthPayStorageSize)
} }
console.error(`=== uploading file ${path} file_size ${file.length} storage_cost:${cost}-token===`) console.error(
`=== uploading file ${path} file_size ${file.length} storage_cost:${cost}-token===`
)
await this.txManager.SendCall("upload", [ await this.txManager.SendCall("upload", [
Buffer.from(this.repoName), Buffer.from(this.repoName),
Buffer.from(path), Buffer.from(path),
file, file,
{value:ethers.utils.parseEther(cost.toString())}, { value: ethers.utils.parseEther(cost.toString()) },
]) ])
console.error(`=== upload ${path} file_size ${file.length} storage_cost:${cost}-token succeed ===`) console.error(
`=== upload ${path} file_size ${file.length} storage_cost:${cost}-token succeed ===`
)
} }
return Status.SUCCEED return Status.SUCCEED
} catch (error: any) { } catch (error: any) {

@ -67,7 +67,7 @@ export class SLIStorage implements Storage {
async () => await this.contract.download(Buffer.from(this.repoName), Buffer.from(path)), async () => await this.contract.download(Buffer.from(this.repoName), Buffer.from(path)),
{ maxRetry: 10 } { maxRetry: 10 }
) )
const buffer = Buffer.from(res.slice(2), "hex") const buffer = Buffer.from(res[0].slice(2), "hex")
const cid = buffer.toString("utf8") const cid = buffer.toString("utf8")
for (let i = 0; i < ipfsConf.gateways.length; i++) { for (let i = 0; i < ipfsConf.gateways.length; i++) {
let gateway = ipfsConf.gateways[Math.floor(Math.random() * ipfsConf.gateways.length)] //random get rpc let gateway = ipfsConf.gateways[Math.floor(Math.random() * ipfsConf.gateways.length)] //random get rpc
@ -149,7 +149,7 @@ export class SLIStorage implements Storage {
let queue = this.batchQueue let queue = this.batchQueue
this.batchQueue = [] this.batchQueue = []
console.error(`[${reason}] commit queue length ${queue.length}`) // console.error(`[${reason}] commit queue length ${queue.length}`)
if (queue.length === 0) return if (queue.length === 0) return
let err let err

@ -1061,6 +1061,11 @@ end-of-stream@^1.1.0, end-of-stream@^1.4.1:
dependencies: dependencies:
once "^1.4.0" once "^1.4.0"
es-main@^1.2.0:
version "1.2.0"
resolved "https://registry.yarnpkg.com/es-main/-/es-main-1.2.0.tgz#b85954f1d9d9f542fcb08685ec19515f969bad16"
integrity sha512-A4tCSY43O/mH4rHjG1n0mI4DhK2BmKDr8Lk8PXK/GBB6zxGFGmIW4bbkbTQ2Gi9iNamMZ9vbGrwjZOIeiM7vMw==
esbuild@^0.17.0: esbuild@^0.17.0:
version "0.17.0" version "0.17.0"
resolved "https://registry.yarnpkg.com/esbuild/-/esbuild-0.17.0.tgz#fcf19373d1d546bdbec1557276284c0e6350380b" resolved "https://registry.yarnpkg.com/esbuild/-/esbuild-0.17.0.tgz#fcf19373d1d546bdbec1557276284c0e6350380b"

Loading…
Cancel
Save